home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / window / _leda_panel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  20.7 KB  |  891 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _leda_panel.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. // defines the LEDA_PANEL operations declared in <LEDA/leda_panel.h>
  18. // using the basic graphics routines from <LEDA/impl/x_basic.h>
  19.  
  20. #include <LEDA/leda_panel.h>
  21. #include <LEDA/impl/x_basic.h>
  22.  
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include <ctype.h>
  26. #include <stdlib.h>
  27.  
  28. enum { Text_Item, 
  29.        String_Item, 
  30.        String_Menu_Item, 
  31.        Int_Item, 
  32.        Slider_Item, 
  33.        Float_Item, 
  34.        Button_Item, 
  35.        Choice_Item,
  36.        Bool_Item};
  37.  
  38. static char* duplicate_string(const char* p)
  39. { char* q = new char[strlen(p)+1];
  40.   if (q==0) 
  41.   { fprintf(stderr,"duplicate_string: out of memory");
  42.     abort();
  43.    }
  44.   strcpy(q,p);
  45.   return q;
  46. }
  47.  
  48.  
  49. void LEDA_PANEL::panel_redraw_func() 
  50. { LEDA_PANEL* p = (LEDA_PANEL*)active_window; 
  51.   p->open(p->XPOS, p->YPOS, 0, 0, 0, 0, 0); }
  52.  
  53.  
  54.  
  55. LEDA_PANEL::LEDA_PANEL(const char* s, int bl)
  56. { header = duplicate_string(s);
  57.   but_layout = bl;
  58.   item_count = 0;
  59.   but_count = 0;
  60.   XPOS = -1;
  61.   YPOS = -1;
  62.   win = 0;
  63.   redraw = panel_redraw_func;
  64.  }
  65.  
  66. void LEDA_PANEL::text_item(const char* s)
  67. { kind[item_count] = Text_Item;
  68.   label_str[item_count] = duplicate_string(s);
  69.   item_count++;
  70. }
  71.  
  72. void LEDA_PANEL::string_item(const char* s, char** x)
  73. { label_str[item_count] = duplicate_string(s);
  74.   ref[item_count] = x;
  75.   kind[item_count] = String_Item;
  76.   item_count++;
  77.  }
  78.  
  79. void  LEDA_PANEL::string_menu_item(const char* s, char** x, const char* /*menu_label*/,
  80.                                    int argc, const char** argv)
  81. { label_str[item_count] = duplicate_string(s);
  82.   ref[item_count] = x;
  83.   kind[item_count] = String_Menu_Item;
  84.   dat1[item_count] = argc;
  85.   choices[item_count] = new char*[argc];
  86.   for(int i = 0; i < argc; i++) 
  87.      choices[item_count][i] = duplicate_string(argv[i]);
  88.   item_count++;
  89.  }
  90.  
  91.  
  92. void LEDA_PANEL::int_item(const char* s, int* x)
  93. { label_str[item_count] = duplicate_string(s);
  94.   ref[item_count] = x;
  95.   kind[item_count] = Int_Item;
  96.   item_count++;
  97.  }
  98.  
  99. void  LEDA_PANEL::slider_item(const char* s, int* x, int min, int max)
  100. { label_str[item_count] = duplicate_string(s);
  101.   ref[item_count] = x;
  102.   dat1[item_count] = min;
  103.   dat2[item_count] = max;
  104.   kind[item_count] = Slider_Item;
  105.   item_count++;
  106.  }
  107.  
  108. void LEDA_PANEL::float_item(const char* s, double* x)
  109. { label_str[item_count] = duplicate_string(s);
  110.   ref[item_count] = x;
  111.   kind[item_count] = Float_Item;
  112.   item_count++;
  113.  }
  114.  
  115. void LEDA_PANEL::choice_item(const char* s, int* address, int argc,
  116.                              const char** argv, int step, int off)
  117. { label_str[item_count] = duplicate_string(s);
  118.   kind[item_count] = Choice_Item;
  119.   ref[item_count] = address;
  120.   dat1[item_count] = argc;
  121.   dat2[item_count] = step;
  122.   offset[item_count] = off;
  123.   choices[item_count] = new char*[argc];
  124.   for(int i=0; i<argc; i++) choices[item_count][i] = duplicate_string(argv[i]);
  125.   item_count++;
  126.  }
  127.  
  128.  
  129. void LEDA_PANEL::bool_item(const char* s, char* address)
  130. { label_str[item_count] = duplicate_string(s);
  131.   kind[item_count] = Bool_Item;
  132.   ref[item_count] = address;
  133.   dat1[item_count] = 2;
  134.   dat2[item_count] = 1;
  135.   offset[item_count] = 0;
  136.   choices[item_count] = new char*[2];
  137.   choices[item_count][0] = duplicate_string("off");
  138.   choices[item_count][1] = duplicate_string("on");
  139.   item_count++;
  140.  }
  141.  
  142.  
  143.  
  144. int LEDA_PANEL::button(const char* s)
  145. { if (but_count == MAX_BUT_NUM) return -1;
  146.   // space before first line of buttons
  147.   if (but_count==0 && item_count>0)  text_item(""); 
  148.   button_str[but_count] = duplicate_string(s);
  149.   return but_count++;
  150.  }
  151.  
  152.  
  153. void  LEDA_PANEL::button_line(int n, const char** b) 
  154. { for(int i=0; i<n; i++) button(b[i]); }
  155.  
  156.  
  157.  
  158. void LEDA_PANEL::activate_string_item(int xoff,int yoff,int yskip,int ytskip, 
  159.                                       int t_length, int n)
  160. {  int y,l,i;
  161.  
  162.    int old = act_str_item;
  163.  
  164.    act_str_item = n;
  165.  
  166.    if (old > -1)
  167.    { y = yoff;
  168.      for(i=0;i<old; i++)
  169.         y += (kind[i] == Text_Item) ? ytskip : yskip; 
  170.      l = dat2[old];
  171.      ::set_mode(1);
  172.      line(win,xoff,y+yskip-3,xoff+t_length,y+yskip-3);
  173.      ::set_mode(0);
  174.      put_text(win,xoff+l*text_width("H"),y+(yskip-text_height("H"))/2," ",1);
  175.    }
  176.  
  177.    y = yoff;
  178.    for(i=0;i<n; i++)
  179.       y += (kind[i] == Text_Item) ? ytskip : yskip; 
  180.    l = dat2[n];
  181.    line(win,xoff,y+yskip-3,xoff+t_length,y+yskip-3);
  182.    put_text(win,xoff+l*text_width("H"),y+(yskip-text_height("H"))/2,"|",1);
  183.  
  184.  }
  185.    
  186.  
  187.  
  188. int LEDA_PANEL::panel_text_edit(int xt, int yt, int t_len, char *str)
  189. { int  i = strlen(str);
  190.   int  x;
  191.   int  cw;
  192.   int  xcoord,ycoord,val;
  193.   int  max_c;
  194.   unsigned long t;
  195.    
  196.   cw = text_width("H");
  197.   x  = xt+i*cw;
  198.  
  199.   max_c = t_len/cw;
  200.  
  201.   put_text(win,xt,yt,str,1);
  202.  
  203.   for(;;)
  204.   { int  k;
  205.     char c = 13;
  206.  
  207.     ::set_read_gc();
  208.  
  209.     while(1)
  210.     { Window w;
  211.       k = get_next_event(&w,&val,&xcoord,&ycoord,&t);
  212.       if (w != win) continue;
  213.       if (k == key_press_event || k == button_press_event) break;
  214.      }
  215.  
  216.      reset_gc();
  217.  
  218.      if (k == key_press_event) c = val;
  219.      if (c == 13) 
  220.      { put_back_event();
  221.        break;
  222.       }
  223.  
  224.      if (i < max_c && isprint(c))
  225.      { str[i]=c;
  226.        str[i+1]=0;
  227.        put_text(win,xt,yt,str,1);
  228.        i++;
  229.        x += cw;
  230.       }
  231.      if(c==8 && i>0)
  232.      { put_text(win,x,yt," ",1);
  233.        i--;
  234.        x -= cw;
  235.       }
  236.      put_text(win,x,yt,"|",1);
  237.    }
  238.  
  239.   str[i]='\0';
  240.  
  241.   ::set_text_font();
  242.  
  243.   return i;
  244. }
  245.  
  246.  
  247. void LEDA_PANEL::put_text_item(int x, int y, const char* s, int t_len)
  248. { char text[128];
  249.   int i;
  250.   int c_len = t_len/text_width("H");
  251.   strcpy(text,s);
  252.   for(i=strlen(s); i<c_len; i++) text[i] = ' ';
  253.   text[c_len] = '\0';
  254.   put_text(win,x,y,text,1);
  255. }
  256.  
  257.  
  258.  
  259. void LEDA_PANEL::draw_choice_item(int i,int x0, int y0, int width,int yskip)
  260. { int c = (*(int*)ref[i]-offset[i])/dat2[i];
  261.   int x = x0+c*width;
  262.   int j;
  263.  
  264.   for(j=0, x=x0; j < dat1[i]; j++, x+=width)
  265.   { ::set_color(0);
  266.     box(win,x+1,y0+4,x+width-1,y0+yskip-3);
  267.     ::set_color(1);
  268.     rectangle(win,x,y0+3,x+width,y0+yskip-2);
  269.     if(j == c) rectangle(win,x+1,y0+4,x+width-1,y0+yskip-3);
  270.     put_ctext(win,x+width/2,y0+yskip/2,choices[i][j],0);
  271.    }
  272. }
  273.  
  274.  
  275. void LEDA_PANEL::draw_bool_item(int i,int x0, int y0, int width,int yskip)
  276. { char c = *(char*)ref[i];
  277.   int x = x0+c*width;
  278.   int j;
  279.  
  280.   for(j=0, x=x0; j < 2; j++, x+=width)
  281.   { ::set_color(0);
  282.     box(win,x+1,y0+4,x+width-1,y0+yskip-3);
  283.     ::set_color(1);
  284.     rectangle(win,x,y0+3,x+width,y0+yskip-2);
  285.     if(j == c) rectangle(win,x+1,y0+4,x+width-1,y0+yskip-3);
  286.     put_ctext(win,x+width/2,y0+yskip/2,choices[i][j],0);
  287.    }
  288.  
  289. }
  290.  
  291.  
  292. void LEDA_PANEL::draw_slider_item(int i, int x01, int x0, int y0,
  293.                                   int length, int yskip, float x)
  294. { float mi = dat1[i];
  295.   float ma = dat2[i];
  296.   int x1 = x0 + length;
  297.   int y1 = y0 + (3*yskip)/4;
  298.   char text[16];
  299.  
  300.   y0 += (1+yskip/4);
  301.  
  302.   if (x < x0) x = x0;
  303.   if (x > x1) x = x1;
  304.  
  305.   int val = int(mi + (ma-mi)*(x-x0)/length + 0.5);
  306.   *(int*)ref[i] = val;
  307.  
  308.   sprintf(text,"%3d",val);
  309.   put_text(win,x01,y0,text,1);
  310.  
  311.   ::set_color(0);
  312.   box(win,int(x+0.5)+1,y0+1,x1-1,y1-1);
  313.   ::set_color(1);
  314.   box(win,x0,y0+1,int(x+0.5),y1-1);
  315.   rectangle(win,x0,y0,x1,y1);
  316.  
  317. }
  318.  
  319. void LEDA_PANEL::draw_button(const char* s, int x, int y, int bw, 
  320.                               int yskip, int pressed)
  321. { 
  322.   if (pressed)
  323.   { ::set_mode(1);
  324.     box(win,x+2,y+5,x+bw-2,y+yskip-4);
  325.     flush_display();
  326.     ::set_mode(0);
  327.    }
  328.   else
  329.   { ::set_color(0);
  330.     box(win,x+1,y+4,x+bw-1,y+yskip-3);
  331.     ::set_color(1);
  332.     if (s) 
  333.        put_ctext(win,x+bw/2,y+yskip/2,s,0);
  334.     else // menu button  "-->"
  335.       { line(win,x+9, y+8,  x+9,  y+20);
  336.         line(win,x+9, y+8,  x+21, y+14);
  337.         line(win,x+9, y+20, x+21, y+14);
  338.         line(win,x+10, y+9,  x+20, y+14);
  339.         line(win,x+10, y+19, x+20, y+14);
  340.        }
  341.     rectangle(win,x+1,y+4,x+bw-1,y+yskip-3);
  342.  
  343.     // shadow
  344.     box(win,x+4,y+yskip-2,x+bw,y+yskip);
  345.     box(win,x+bw,y+7,x+bw+2,y+yskip);
  346.  
  347.    }
  348.  
  349.   
  350.  }
  351.  
  352.  
  353. static int read_panel_at(const char* header, int n, char** but,int x, int y)
  354. { LEDA_PANEL p(header);
  355.   for(int i=0; i<n; i++) p.button(but[i]);
  356.   return p.open(x,y,0,0,0,0,3);
  357.  }
  358.  
  359.  
  360. int  LEDA_PANEL::open(int xpos, int ypos, int win_x, int win_y, 
  361.                       int win_width, int win_height, int mode)
  362. {
  363.  
  364.  
  365.   // mode = 0:  just display panel window  on screen
  366.   // mode = 1:  display, read (blocking), and close 
  367.   // mode = 2:  read
  368.   // mode = 3:  display, read (non-blocking) , and close
  369.  
  370.  
  371.   char  text[128];
  372.   char  str[128];
  373.  
  374.  
  375. repaint:
  376.  
  377.   int   width = (win) ? ::window_width(win) : 100;
  378.   int   height; 
  379.  
  380.  
  381.   int   xoff  = 20;       /* left and right boundary space */
  382.   int   yoff  = 10;       /* top and bottom boundary space */
  383.   int   xoff1 =  0;       /* start of slider items    */
  384.   int   xoff2 =  0;       /* start of all other items */
  385.  
  386.   int   bxoff;            /* left and right button boundary space */
  387.  
  388.   int   sl_length = 200;  /* slider item length */
  389.   int   t_length  = 200;  /* string/int/float item length */
  390.  
  391.   int   ytskip = 18;      /* height of text items   */
  392.   int   yskip  = 28;      /* height of other items  */
  393.  
  394.   int   bw     = 50;      /* button width (minimal) */
  395.   int   bskip  = 15;      /* button space */
  396.   int   bw1;              /* bw + bskip   */
  397.  
  398.   int   cw     = 30;      /* choice field width (minimal) */
  399.  
  400.  
  401.   int   but_per_line;
  402.   int   but_lines;
  403.  
  404.  
  405.   int   but,w,i,j,x,y,yt;
  406.  
  407.   int   save_lw, save_ls, save_mo;
  408.  
  409.   int   user_buttons = but_count;
  410.  
  411.   unsigned long t;
  412.  
  413.   open_display();
  414.  
  415.   save_lw = ::set_line_width(1);
  416.   save_ls = ::set_line_style(0);
  417.   save_mo = ::set_mode(0);
  418.  
  419.   if (but_count==0)
  420.   { button("CONTINUE");
  421.     button("QUIT");
  422.    }
  423.  
  424.  
  425.   height = 2*yoff;
  426.  
  427.   for(i=0;i<item_count; i++)
  428.     if (kind[i] != Text_Item)
  429.        { height += yskip;
  430.          if ((w = text_width(label_str[i])) > xoff1) xoff1 = w;
  431.  
  432.          if (kind[i] == Choice_Item)
  433.          { int j;
  434.            for(j=0; j<dat1[i];j++)
  435.            if ((w = text_width(choices[i][j])) > cw) cw = w;
  436.           }
  437.        }
  438.     else
  439.        height += ytskip;
  440.  
  441.   cw    += 10;
  442.  
  443.   xoff1 += 25;
  444.  
  445.   xoff2 = xoff1 + 35;
  446.  
  447.  
  448.   if ((w = text_width(header)) > width) width = w;
  449.  
  450.   for(i=0;i<item_count; i++)
  451.   { switch (kind[i])
  452.     {
  453.       case  Text_Item:
  454.                   if ((w = 2*xoff + text_width(label_str[i])) > width) width=w;
  455.                   if ((w = text_width(label_str[i])-xoff2) > sl_length)
  456.                      sl_length = w;
  457.                   if (w > t_length) t_length = w;
  458.                   break;
  459.  
  460.  
  461.       case Choice_Item:
  462.                  if ((w = xoff2 + cw*dat1[i] + xoff) > width) width = w;
  463.                  break;
  464.  
  465.       case Slider_Item:
  466.                  if ((w = xoff2+sl_length+xoff) > width) width = w;
  467.                  break;
  468.  
  469.       case String_Menu_Item:
  470.                  if ((w = xoff2+t_length+2*yskip+xoff) > width) width = w;
  471.                  break;
  472.  
  473.       default:   if ((w = xoff2+t_length+xoff) > width) width = w;
  474.                  break;
  475.      }
  476.    }
  477.  
  478.  
  479.   for(i=0; i < but_count; i++)
  480.      if ((w = text_width(button_str[i])) > bw) bw = w;
  481.  
  482.   bw  = bw += 10;
  483.   bw1 = bw + bskip;
  484.  
  485.   if (width < bw1+bskip) width = bw1+bskip;
  486.  
  487.   if (but_layout == 0)
  488.      but_per_line = (width-bskip)/bw1;
  489.   else
  490.      but_per_line = 1;
  491.  
  492.   but_lines = but_count/but_per_line;
  493.  
  494.   if (but_count % but_per_line) but_lines++;
  495.  
  496.   if (but_lines == 1)
  497.      bxoff = (width - but_count * bw1 + bskip)/2;
  498.   else
  499.      bxoff = (width - but_per_line * bw1 + bskip)/2;
  500.  
  501.   height += but_lines * yskip;
  502.  
  503.   for (i=0; i< but_lines; i++)
  504.      kind[item_count+i] = Button_Item;
  505.  
  506.  
  507.   if(XPOS == -1)
  508.     if (xpos == -1)
  509.       if (win_width == 0)
  510.          { /* center panel window on the screen */
  511.            XPOS = (display_width() - width)/2;
  512.            YPOS = (display_height() - height)/2;
  513.           }
  514.       else
  515.          { /* center panel window on draw window */
  516.            XPOS = win_x + (win_width - width)/2;
  517.            YPOS = win_y + (win_height- height)/2;
  518.           }
  519.     else /* use supplied coordinates */
  520.       { XPOS = xpos;
  521.         YPOS = ypos;
  522.        }
  523.  
  524.   //if (win==0) win = open_window(XPOS,YPOS,width,height,header,"LEDA PANEL");
  525.  
  526.   if (win==0) 
  527.   { LEDA_WINDOW::open(width,height,XPOS,YPOS,header);
  528.     set_show_coordinates(0);
  529.     redraw = panel_redraw_func;
  530.     win = draw_win;
  531.    }
  532.  
  533.  
  534. //repaint:
  535.  
  536.   //clear_window(win,orange);
  537.  
  538.   act_str_item = -1;
  539.  
  540.   ::set_color(1);
  541.  
  542.   y = yoff;
  543.  
  544.   for(i=0;i<item_count; i++)
  545.   {
  546.     yt = y + (yskip - text_height("H"))/2;
  547.  
  548.     if (kind[i] != Text_Item) put_text(win,xoff,yt,label_str[i],0);
  549.  
  550.     switch (kind[i]) {
  551.  
  552.     case Text_Item:
  553.         { put_text(win,xoff,y,label_str[i],0);
  554.           break;
  555.          }
  556.  
  557.  
  558.     case Choice_Item:
  559.         { draw_choice_item(i,xoff2,y,cw,yskip);
  560.           break;
  561.          }
  562.  
  563.     case Bool_Item:
  564.         { draw_bool_item(i,xoff2,y,cw,yskip);
  565.           break;
  566.          }
  567.  
  568.     case Slider_Item:
  569.         { float d = float(sl_length)/(dat2[i]-dat1[i]);
  570.           float x = xoff2 + d * (*(int*)ref[i]-dat1[i]);
  571.           draw_slider_item(i,xoff1,xoff2,y,sl_length,yskip,x);
  572.           break;
  573.          }
  574.  
  575.     case Int_Item:
  576.         { sprintf(text,"%d",*(int*)ref[i]);
  577.           put_text(win,xoff2,yt,text,1);
  578.           dat2[i] = strlen(text);
  579.           line(win,xoff2,y+yskip-4,xoff2+t_length,y+yskip-4);
  580.           if (act_str_item == -1) 
  581.               activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  582.           break;
  583.          }
  584.  
  585.     case Float_Item:
  586.         { sprintf(text,"%f",*(double*)ref[i]);
  587.           put_text(win,xoff2,yt,text,1);
  588.           dat2[i] = strlen(text);
  589.           line(win,xoff2,y+yskip-4,xoff2+t_length,y+yskip-4);
  590.           if (act_str_item == -1) 
  591.               activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  592.           break;
  593.          }
  594.   
  595.     case String_Item:
  596.         { put_text(win,xoff2,yt,*(char**)ref[i],1);
  597.           dat2[i] = strlen(*(char**)ref[i]);
  598.           line(win,xoff2,y+yskip-4,xoff2+t_length,y+yskip-4);
  599.           if (act_str_item == -1) 
  600.               activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  601.           break;
  602.          }
  603.  
  604.     case String_Menu_Item:
  605.         { put_text(win,xoff2,yt,*(char**)ref[i],1);
  606.           dat2[i] = strlen(*(char**)ref[i]);
  607.           line(win,xoff2,y+yskip-4,xoff2+t_length,y+yskip-4);
  608.           draw_button(0,xoff2+t_length+10,y-1,yskip,yskip-1,0);
  609.           if (act_str_item == -1) 
  610.               activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  611.           break;
  612.          }
  613.     
  614.     
  615.     }
  616.  
  617.     if (kind[i] == Text_Item)
  618.         y += ytskip;
  619.     else
  620.         y += yskip;
  621.  
  622.   }
  623.  
  624.   y -= yskip;
  625.  
  626.   for(i=0; i < but_count; i++)
  627.     { if (i % but_per_line == 0)
  628.       { y += yskip;
  629.         x = bxoff;
  630.        }
  631.       draw_button(button_str[i],x,y,bw,yskip,0);
  632.       x += bw1;
  633.      }
  634.  
  635.  
  636.   if (mode == 0) return -1;
  637.  
  638.  
  639.  
  640.  
  641.   but = -1;
  642.  
  643.   while(but == -1)
  644.   { int b;
  645.     i = -1;
  646.  
  647.  
  648.     while (i < 0 || i >= item_count+but_lines)
  649.     { int k;
  650.       ::set_read_gc();
  651.       while (1)
  652.       { Window w;
  653.         k = get_next_event(&w,&b,&x,&y,&t);
  654.         if (w == win)
  655.         { if (k == button_press_event || k == key_press_event) break;
  656.           if (k == configure_event) 
  657.           { reset_gc();
  658.             goto repaint;
  659.            }
  660.          }
  661.         else
  662.           if (mode == 3 && k==button_press_event) 
  663.           { put_back_event();
  664.             reset_gc();
  665.             goto end;
  666.            }
  667.        }
  668.       reset_gc();
  669.  
  670.       if (k==button_press_event)
  671.         { for(i=0,j=yoff;i<item_count+but_lines && y>j; i++)
  672.             if (kind[i] == Text_Item)
  673.                j += ytskip;
  674.             else
  675.                j += yskip;
  676.   
  677.            if (y <= j) i--;
  678.          }
  679.        else  /* key pressed */
  680.        { if (b == 13 && act_str_item > -1) /* return */
  681.          { j = act_str_item;
  682.            for(;;)
  683.            { j = (j + 1) % item_count;
  684.              k =  kind[j]; 
  685.              if (k==String_Item || k==String_Menu_Item || 
  686.                  k==Int_Item || k == Float_Item) break;
  687.              }
  688.            activate_string_item(xoff2,yoff,yskip,ytskip,t_length,j);
  689.          }
  690.          else
  691.          { x = xoff2;
  692.            i = act_str_item;
  693.            for(k=0,j=yoff; k <= i; k++)
  694.             if (kind[k] == Text_Item)
  695.                j += ytskip;
  696.             else
  697.                j += yskip;
  698.            put_back_event();
  699.           }
  700.        }
  701.      }
  702.  
  703.     y  = j-yskip;
  704.     yt = y + (yskip - text_height("H"))/2;
  705.  
  706.     switch (kind[i]) {
  707.  
  708.     case Text_Item: break;
  709.  
  710.     case Slider_Item:
  711.     { Window w = win;
  712.       int xx = 0;
  713.       if (x < xoff2 || x > xoff2+sl_length) break;
  714.       ::set_read_gc();
  715.       while(w == win)
  716.       { if (xx != x)
  717.         { xx = x;
  718.           reset_gc();
  719.           draw_slider_item(i,xoff1,xoff2,y,sl_length,yskip,xx);
  720.           ::set_read_gc();
  721.          }
  722.         if (get_next_event(&w,&b,&x,&j,&t) == button_release_event) break;
  723.        }
  724.       reset_gc();
  725.       break;
  726.      }
  727.  
  728.     case Int_Item:
  729.     { int* ptr = (int*)ref[i];
  730.       sprintf(str,"%d",*ptr);
  731.       activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  732.       panel_text_edit(xoff2,yt,t_length,str);
  733.       *ptr = atoi(str);
  734.       sprintf(str,"%d",*ptr);
  735.       dat2[i] = strlen(str);
  736.       sprintf(text,"%s|                    ",str);
  737.       put_text_item(xoff2,yt,text,t_length);
  738.       break;
  739.      }
  740.  
  741.     case Float_Item:
  742.     { double* ptr = (double*)ref[i];
  743.       sprintf(str,"%f",*ptr);
  744.       activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  745.       panel_text_edit(xoff2,yt,t_length,str);
  746.       *ptr = (double)atof(str);
  747.       sprintf(str,"%f",*ptr);
  748.       dat2[i] = strlen(str);
  749.       sprintf(text,"%s|                    ",str);
  750.       put_text_item(xoff2,yt,text,t_length);
  751.       break;
  752.      }
  753.  
  754.     case String_Item:
  755.     { strcpy(str,*(char**)ref[i]);
  756.       activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  757.       panel_text_edit(xoff2,yt,t_length,str);
  758.       delete *(char**)ref[i];
  759.       *(char**)ref[i] = duplicate_string(str);
  760.       dat2[i] = strlen(str);
  761.       put_text_item(xoff2,yt,str,t_length);
  762.       break;
  763.      }
  764.  
  765.     case String_Menu_Item:
  766.     { activate_string_item(xoff2,yoff,yskip,ytskip,t_length,i);
  767.       strcpy(str,*(char**)ref[i]);
  768.       if (x < xoff2+t_length+10)
  769.          { strcpy(str,*(char**)ref[i]);
  770.            panel_text_edit(xoff2,yt,t_length,str);
  771.           }
  772.       else
  773.          { Window w;
  774.            draw_button(0,xoff2+t_length+10,y-1,yskip,yskip-1,1);
  775.            while (get_next_event(&w,&b,&x,&j,&t) != button_release_event);
  776.            draw_button(0,xoff2+t_length+10,y-1,yskip,yskip-1,1);
  777.            int sel = read_panel_at(label_str[i],dat1[i],choices[i],
  778.                                    XPOS+xoff2+t_length+16, YPOS+y+24);
  779.            if (sel > -1) strcpy(str,(choices[i])[sel]);
  780.           }
  781.  
  782.       delete *(char**)ref[i];
  783.       *(char**)ref[i] = duplicate_string(str);
  784.       dat2[i] = strlen(str);
  785.       sprintf(text,"%s|                   ",str);
  786.       put_text_item(xoff2,yt,text,t_length);
  787.       break;
  788.      }
  789.  
  790.  
  791.    case Choice_Item:
  792.    { j = (x-xoff2)/cw;
  793.      if (j >= 0 && j<dat1[i])
  794.      { *(int*)ref[i] = offset[i] + j * dat2[i];
  795.        draw_choice_item(i,xoff2,y,cw,yskip);
  796.       }
  797.      break;
  798.     }
  799.  
  800.    case Bool_Item:
  801.    { j = (x-xoff2)/cw;
  802.      if (j >= 0 && j<dat1[i])
  803.      { *(char*)ref[i] = offset[i] + j * dat2[i];
  804.        draw_bool_item(i,xoff2,y,cw,yskip);
  805.       }
  806.      break;
  807.     }
  808.  
  809.    case Button_Item:
  810.    { j = (x-bxoff)/bw1;
  811.      i = (i-item_count)*but_per_line +j;
  812.      if (x > bxoff && j < but_per_line && i < but_count)
  813.      { Window w;
  814.        draw_button(button_str[i],bxoff+j*bw1,y,bw,yskip,1);
  815.        while (get_next_event(&w,&b,&b,&b,&t) != button_release_event);
  816.        but = i;
  817.        //if (mode == 2) draw_button(button_str[i],bxoff+j*bw1,y,bw,yskip,1);
  818.       }
  819.      break;
  820.     }
  821.  
  822.    }
  823.  
  824.   }
  825.  
  826.  
  827.  if (mode == 2) // redisplay
  828.      open(XPOS,YPOS,0,0,0,0,0);
  829.  
  830. /*
  831.   window_position(win,&(XPOS),&(YPOS));
  832. */
  833.  
  834. end:
  835.  
  836.  
  837.   ::set_line_width(save_lw);
  838.   ::set_line_style(save_ls);
  839.   ::set_mode(save_mo);
  840.  
  841.   if (user_buttons == 0)
  842.   { but_count = 0;
  843.     item_count--;
  844.     if (but == 1)   /* quit button pressed */
  845.     { close_display();
  846.       exit(0);
  847.      }
  848.    }
  849.  
  850.   if (mode != 2) close();
  851.  
  852.   return but;
  853. }
  854.  
  855.  
  856. void LEDA_PANEL::display(int xpos, int ypos, int win_x, int win_y, int win_width, int win_height)
  857. { open(xpos, ypos, win_x, win_y, win_width, win_height, 0); }
  858.  
  859. /*
  860. int  LEDA_PANEL::read(int xpos, int ypos, int win_x, int win_y, int win_width, int win_height)
  861. { return open(xpos, ypos, win_x, win_y, win_width, win_height, 2); }
  862. */
  863.  
  864. int  LEDA_PANEL::read() { return open(XPOS,YPOS,0,0,0,0,2); }
  865.  
  866.  
  867.  
  868. void  LEDA_PANEL::close() 
  869. { close_window(win);
  870.   win = 0;
  871.   draw_win = 0;
  872.  }
  873.  
  874.  
  875.  
  876. LEDA_PANEL::~LEDA_PANEL() 
  877. { delete header; 
  878.   for(int i = 0; i<item_count; i++)
  879.   { delete label_str[i];
  880.     if (   kind[i] == String_Menu_Item 
  881.         || kind[i] == Choice_Item 
  882.         || kind[i] == Bool_Item    )
  883.     { for(int j = 0; j < dat1[i]; j++) delete choices[i][j];
  884.       delete choices[i];
  885.      }
  886.    }
  887.   for(int j = 0; j<but_count; j++) delete button_str[j];
  888. }
  889.  
  890.  
  891.